?? 1076_9.html
字號:
<html>
<head>
<title>VHDL LRM- Introduction</title>
</head>
<body>
<h1><a name="9">Section 9</a></h1>
<a href="../../HTML/HOMEPG.HTM"><img src="HP.GIF" border=0></a>
<a href="1076_TOC.HTM"><img src="TOP.GIF" BORDER=0></a>
<a href="1076_8.HTM"><img src="LEFT.GIF" BORDER=0></a>
<a href="1076_10.HTM"><img src="RIGHT.GIF" BORDER=0></a>
<HR>
<h1>Concurrent statements</h1>
<p>
<p>The various forms of concurrent statements are described in this section. Concurrent statements are used to define interconnected blocks and processes that jointly describe the overall behavior or structure of a design. Concurrent statements execure asynchronously with respect to each other.
<pre> concurrent_statement ::=
block_statement
| process_statement
| concurrent_procedure_call_statement
| concurrent_assertion_statement
| concurrent_signal_assignment_statement
| component_instantiation_statement
| generate_statement
</pre>
<p>The primary concurrent statements are the block statement, which groups together other concurrent statements, and the process statement, which represents a single independent sequential process. Additional concurrent statements provide convenient syntax for representing simple, commonly occurring forms of processes, as well as for representing structural decomposition and regular descriptions.
<p>Within a given simulation cycle, an implementation may execute concurrent statements in parallel or in some order. The language does not define the order, if any, in which such statements will be executed. A description that depends upon a particular order of execution of concurrent statements is erroneous.
<p>All concurrent statements may be labeled. Such labels are implicitly declared at the beginning of the declarative part of the innermost enclosing entity declaration, architecture body, block statement, or generate statement.
<h2><a name="9.1"> <a href = "1076_9.HTM#9.1"> 9.1 </a> Block statement</a></h2>
<p>A block statement defines an internal block representing a portion of a design. Blocks may be hierarchically nested to support design decomposition.
<pre> block_statement ::=
<i>block</i>_label :
<b>block</b> [ ( <i>guard</i>_expression ) ] [ <b>is</b> ]
block_header
block_declarative_part
<b>begin</b>
block_statement_part
<b>end block</b> [ <i>block</i>_label ] ;
block_header ::=
[ generic_clause
[ generic_map_aspect ; ] ]
[ port_clause
[ port_map_aspect ; ] ]
block_declarative_part ::=
{ block_declarative_item }
block_statement_part ::=
{ concurrent_statement }
</pre>
<p>If a guard expression appears after the reserved word <b>block</b>, then a signal with the simple name GUARD of predefined type BOOLEAN is implicitly declared at the beginning of the declarative part of the block, and the guard expression defines the value of that signal at any given time (see <a href = "1076_12.HTM#12.6.4"> 12.6.4 </a> ). The type of the guard expression must be type BOOLEAN. Signal GUARD may be used to control the operation of certain statements within the block (see <a href = "1076_9.HTM#9.5"> 9.5 </a> ).
<p>The implicit signal GUARD must not have a source.
<p>If a block header appears in a block statement, it explicitly identifies certain values or signals that are to be imported from the enclosing environment into the block and associated with formal generics or ports. The generic<b> </b>and port<b> </b>clauses define the formal generics and formal ports of the block (see <a href = "1076_1.HTM#1.1.1.1"> 1.1.1.1 </a> and <a href = "1076_1.HTM#1.1.1.2"> 1.1.1.2 </a> ); the generic map and port map aspects define the association of actuals with those formals (see <a href = "1076_5.HTM#5.2.1.2"> 5.2.1.2 </a> ). Such actuals are evaluated in the context of the enclosing declarative region.
<p>If a label appears at the end of a block statement, it must repeat the block label.
<h4>NOTES</h4>
<p>1--The value of signal GUARD is always defined within the scope of a given block, and it does not implicitly extend to design entities bound to components instantiated within the given block. However, the signal GUARD may be explicitly passed as an actual signal in a component instantiation in order to extend its value to lower-level components.
<p>2--An actual appearing in a port association list of a given block can never denote a formal port of the same block.
<h2><a name="9.2"> <a href = "1076_9.HTM#9.2"> 9.2 </a> Process statement</a></h2>
<p>A process statement defines an independent sequential process representing the behavior of some portion of the design.
<pre> process_statement ::=
[ <i>process</i>_label : ]
[ <b>postponed</b> ] <b>process</b> [ ( sensitivity_list ) ] [ <b>is</b> ]
process_declarative_part
<b>begin</b>
process_statement_part
<b>end</b> [ <b>postponed</b> ]<b> process</b> [ <i>process</i>_label ] ;
process_declarative_part ::=
{ process_declarative_item }
process_declarative_item ::=
subprogram_declaration
| subprogram_body
| type_declaration
| subtype_declaration
| constant_declaration
| variable_declaration
| file_declaration
| alias_declaration
| attribute_declaration
| attribute_specification
| use_clause
| group_type_declaration
| group_declaration
process_statement_part ::=
{ sequential_statement }
</pre>
<p>If the reserved word <b>postponed</b> precedes the initial reserved word <b>process</b>, the process statement defines a <i>postponed process</i>; otherwise, the process statement defines a <i>nonpostponed process</i>.
<p>If a sensitivity list appears following the reserved word <b>process</b>, then the process statement is assumed to contain an implicit wait statement as the last statement of the process statement part; this implicit wait statement is of the form
<pre> <b>wait</b> <b>on</b> sensitivity_list ;
</pre>
<p>where the sensitivity list of the wait statement is that following the reserved word <b>process</b>. Such a process statement must not contain an explicit wait statement. Similarly, if such a process statement is a parent of a procedure, then that procedure may not contain a wait statement.
<p>Only static signal names (see <a href = "1076_6.HTM#6.1"> 6.1 </a> ) for which reading is permitted may appear in the sensitivity list of a process statement.
<p>If the reserved word <b>postponed</b> appears at the end of a process statement, the process must be a postponed process. If a label appears at the end of a process statement, the label must repeat the process label.
<p>It is an error if a variable declaration in a process declarative part declares a shared variable.
<p>The execution of a process statement consists of the repetitive execution of its sequence of statements. After the last statement in the sequence of statements of a process statement is executed, execution will immediately continue with the first statement in the sequence of statements.
<p>A process statement is said to be a <i>passive</i> <i>process</i> if neither the process itself, nor any procedure of which the process is a parent,contains a signal assignment statement. Such a process, or any concurrent statement equivalent to such a process, may appear in the entity statement part of an entity declaration.
<h4>NOTES</h4>
<p>1--The above rules imply that a process that has an explicit sensitivity list always has exactly one (implicit) wait statement in it, and that wait statement appears at the end of the sequence of statements in the process statement part. Thus, a process with a sensitivity list always waits at the end of its statement part; any event on a signal named in the sensitivity list will cause such a process to execute from the beginning of its statement part down to the end, where it will wait again. Such a process executes once through at the beginning of simulation, suspending for the first time when it executes the implicit wait statement.
<p>2--The time at which a process executes after being resumed by a wait statement(see <a href = "1076_8.HTM#8.1"> 8.1 </a> ) differs depending on whether the process is postponed or nonpostponed. When a nonpostponed process is resumed, it executes in the current simulation cycle (see <a href = "1076_2.HTM#2.6.4"> 2.6.4 </a> ). When a postponed process is resumed, it does not execute until a simulation cycle occurs in which the next simulation cycle is not a delta cycle. In this way, a postponed process accesses the values of signals that are the "final" values at the current simulated time.
<p>3--The conditions that cause a process to resume execution may no longer hold at the time the process resumes execution if the process is a postponed process.
<h2><a name="9.3"> <a href = "1076_9.HTM#9.3"> 9.3 </a> Concurrent procedure call statements</a></h2>
<p>A concurrent procedure call statement represents a process containing the corresponding sequential procedure call statement.
<pre> concurrent_procedure_call_statement ::=
[ label : ] [ <b>postponed</b> ] procedure_call ;
</pre>
<p>For any concurrent procedure call statement, there is an equivalent process statement. The equivalent process statement is a postponed process if and only if the concurrent procedure call statement includes the reserved word <b>postponed</b>. The equivalent process statement has a label if and only if the concurrent procedure call statement has a label; if the equivalent process statement has a label, it is the same as that of the concurrent procedure call statement. The equivalent process statement also has no sensitivity list, an empty declarative part, and a statement part that consists of a procedure call statement followed by a wait statement.
<p>The procedure call statement consists of the same procedure name and actual parameter part that appear in the concurrent procedure call statement.
<p>If there exists a name that denotes a signal in the actual part of any association element in the concurrent procedure call statement, and that actual is associated with a formal parameter of mode <b>in</b> or <b>inout</b>, then the equivalent process statement includes a final wait statement with a sensitivity clause that is constructed by taking the union of the sets constructed by applying the rule of <a href = "1076_8.HTM#8.1"> 8.1 </a> to each actual part associated with a formal parameter.
<p>Execution of a concurrent procedure call statement is equivalent to execution of the equivalent process statement.
<p><i>Example:</i>
<pre> CheckTiming (tPLH, tPHL, Clk, D, Q); -- A concurrent procedure called statement.
<b>process</b> -- The equivalent process.
<b>begin</b>
CheckTiming (tPLH, tPHL, Clk, D, Q);
<b>wait on </b>Clk, D, Q;
<b>end process</b>;
</pre>
</pre>
<h4>NOTES</h4>
<p>1--Concurrent procedure call statements make it possible to declare procedures representing commonly used processes and to create such processes easily by merely calling the procedure as a concurrent statement. The wait statement at the end of the statement part of the equivalent process statement allows a procedure to be called without having it loop interminably, even if the procedure is not necessarily intended for use as a process (i.e., it contains no wait statement). Such a procedure may persist over time (and thus the values of its variables may retain state over time) if its outermost statement is a loop statement and the loop contains a wait statement. Similarly, such a procedure may be guaranteed to execute only once, at the beginning of simulation, if its last statement is a wait statement that has no sensitivity clause, condition clause, or timeout clause.
<p>2--The value of an implicitly declared signal GUARD has no effect on evaluation of a concurrent procedure call unless it is explicitly referenced in one of the actual parts of the actual parameter part of the concurrent procedure call statement.
<h2><a name="9.4"> <a href = "1076_9.HTM#9.4"> 9.4 </a> Concurrent assertion statements</a></h2>
<p>A concurrent assertion statement represents a passive process statement containing the specified assertion statement.
<pre> concurrent_assertion_statement ::=
[ label : ] [ <b>postponed</b> ] assertion ;
</pre>
<p>For any concurrent assertion statement, there is an equivalent process statement. The equivalent process statement is a postponed process if and only if the concurrent assertion statement includes the reserved word <b>postponed</b>. The equivalent process statement has a label if and only if the concurrent assertion statement has a label; if the equivalent process statement has a label, it is the same as that of the concurrent assertion statement. The equivalent process statement also has no sensitivity list, an empty declarative part, and a statement part that consists of an assertion statement followed by a wait statement.
<p>The assertion statement consists of the same condition, <b>report</b> clause, and <b>severity</b> clause that appear in the concurrent assertion statement.
<p>If there exists a name that denotes a signal in the Boolean expression that defines the condition of the assertion, then the equivalent process statement includes a final wait statement with a sensitivity clause that is constructed by applying the rule of <a href = "1076_8.HTM#8.1"> 8.1 </a> to that expression; otherwise, the equivalent process statement contains a final wait statement that has no explicit sensitivity clause, condition clause, or timeout clause.
<p>Execution of a concurrent assertion statement is equivalent to execution of the equivalent process statement.
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -