semi合集-English.pdf - 第1781页

SEMI E42-0704 © SEMI 1995, 2004 50 of the attributes of the original are copie d directly. These operations are included in Namespace Management i n Section 9.4.1. 8.2.2.1 Create Recipe — A reci pe is created when a reci…

SEMI E42-0704 © SEMI 1995, 2004 49

in the main recipe's attributes. Linking resolves all

identifiers explicitly for recipes that are within the

namespace.

unlink — At times it may be desirable to undo the link

operation. The unlink operation clears those attributes

set by the last link operation. A write-protected recipe

may not be unlinked.

approve — The factory uses the recipe's approval level

to indicate the level of its authorization. For example,

approval levels of 1, 2, and 3 may indicate “write-

protected,” “authorized for engineering,” and

“authorized for production,” respectively.

modify variable parameters — The variable

parameter definitions of a linked recipe may be

adjusted for a specific executing agent to achieve the

desired result. For example, a generic parameter for

time may be incremented repeatedly for a specific

furnace until it goes out of range, which indicates that it

needs to be cleaned. If the recipe did not previously

have an agent-specific dataset for this agent, this

operation causes one to be created.

certify — An authorized user (typically by the process

engineer who developed the recipe) assigns it a

certification-level to indicate that it achieves the

desired result on a specific executing agent. The factory

may require certain certification levels for production.

de-certify — the certification level of the recipe is reset

to zero.

unprotect — Before a recipe can be updated, deleted,

renamed, re-linked, or unlinked, the recipe must be

unprotected.

delete — Deleting a recipe causes it to be removed

from the namespace.

8.2 Description of Operations — Operations that

require additional messages are of two types:

operations that may be performed on more than one

recipe (such as certify recipe) and operations that may

require interactions with a recipe executor to complete

(verify recipe). The scenario for verify recipe is shown

in Section 9.4.7.

The remaining operations that require additional

messages are invoked with the namespace service

RMNAction, where multiple recipes are specified for

the operation. Operations such as these may require

more time to complete. The initial response to the

message service request only indicates the intent to

perform the operation. In this case, the scenario is

illustrated by Figure 8.1 and Figure 12.2, Section 12.2.

The namespace manager performs the operation for

each recipe, in the order specified, and upon the

completion of each operation, sends the notification

message RMNComplete with the results for that

operation. (See Sections 12.15 and 12.17 for additional

details.)

Figure 8.1

Message Flow with Completion Notification

Recipe management operations are categorized into

three types: recipe origination, recipe building, and

recipe authorization.

Recipe origination includes those operations that

create or modify an entire recipe. Recipe building

includes the verification, link, unlink, and modify

variable parameter operations. Recipe authorization

includes the write-protect, unprotect, approve, and

certify operations.

Except for those operations that only provide

information, recipe management operations change the

state of the recipe. Section 8.3 contains the complete

state model, and a table of transitions is given in Table

3.1. Substates of this model are provided for illustration

in sections defining the operations that affect these

substates.

8.2.1 General Requirements — The generic length and

timestamp attributes AttrLength

and AttrChgTime shall

be updated whenever any other generic attribute

changes value.

An agent-specific dataset for a specific agent exists

only when a non-required attribute is given a non-

default value, such as whenever a recipe is certified for

a given agent. If the non-required attributes are all

cleared, the agent-specific dataset is removed and no

longer exists. Otherwise, the agent-specific length and

timestamp attributes for an agent-specific dataset shall

be updated whenever one of its attributes changes

value.

8.2.2 Recipe Origination — A recipe may be originated

by the create recipe operation and by the copy recipe

operation. The copy recipe operation creates a duplicate

of an original recipe and assigns it a new identifier. All

SEMI E42-0704 © SEMI 1995, 2004 50

of the attributes of the original are copied directly.

These operations are included in Namespace

Management in Section 9.4.1.

8.2.2.1 Create Recipe — A recipe is created when a

recipe body is first entered into a namespace and

assigned a new identifier. The recipe's mandatory

attributes are set. All other attributes take on their

default values. The values for the attributes

BodyLength

, EditTime, and EditedBy are required to be

provided by the initiator of the create operation. The

attribute BodyFormat

is also provided at this time if it is

not in source form (i.e., if BodyFormat

has a non-

default value).

A newly created recipe has an active state model

(Figure 8.7). The recipe is in the UNVERIFIED,

UNLINKED, UNAPPROVED, UNPROTECTED, and

UNCERTIFIED states.

The create recipe operation is invoked with the

RMNCreate service.

8.2.2.2 Update Recipe — The update operation is

identical to that of create except that an unprotected

recipe with the specified identifier already exists, and

the new body replaces the existing body. Attributes

concerning the body are provided by the initiator of the

request, as for the create operation. All non-mandatory

attributes are cleared (reset to their default values).

Any existing agent-specific datasets are discarded.

The update recipe operation is invoked with the

RMNUpdate service.

8.2.3 Recipe Building — Building a recipe is a two-step

process. First the recipe is verified and then linked.

8.2.3.1 Verify Recipe — The verify operation is the

only time it is necessary to parse the contents of the

recipe body until the recipe is executed. The primary

purpose of this process is to ensure that the syntactical

and lexical structure of the body is correct. One or more

checks for semantic correctness may also be performed

as part of the verification operation, but this is not

required.

Actual verification is performed by a member agent's

recipe executor at the request of a namespace

manager. For this reason, this operation is also

discussed under namespace management in Section

9.4.7.

Recipes may be stored in a namespace in an incomplete

or unfinished form. For recipes in source form, the

verification procedure shall be performed only at the

request of the user. It shall not be performed

automatically.

There are four attributes affected by the verification

operation: Verified

, EstRunTime, ExtRef, and

Parameters

The boolean generic attribute Verified

is used to

indicate the recipe's state with respect to this procedure.

Verified

is cleared when a recipe is first created and

whenever it is updated. Verified

is set TRUE only when

the recipe passes the verification by a recipe executor.

A recipe is considered to be verified if, and only if, the

Verified attribute is TRUE. Figure 8.2 illustrates the

recipe's VERIFICATION state. For a description of the

transitions, see Table 8.1 in Section 8.3.

Figure 8.2

Verification State Model

The values for the attributes EstRunTime

, ExtRef,

Parameters

, and VerificationID are returned (where set)

by the recipe executor when the verification has been

successful. If the operation is unsuccessful, they shall

be cleared.

ExtRef

contains a list of all external references found

within the body of the recipe by the recipe executor.

These references may be explicit

or implicit, leaving

the class and/or version unspecified.

The verify recipe operation is invoked with the

RMNAction service.

8.2.3.2 Link Recipe — The link operation is a required

operation that may be requested at any time by the

operator or supervisor. Successful completion of the

link operation indicates that the recipe is ready for

execution. For single-part recipes without variable

parameters, linking consists only of setting the generic

SEMI E42-0704 © SEMI 1995, 2004 51

attribute Linked to TRUE. Figure 8.3 illustrates the

LINKAGE state of the recipe. For a description of the

transitions, see Table 8.1 in Section 8.3.

Figure 8.3

Link State Model

For multi-part recipes, this operation also collects

external references and variable parameter definitions

into the LinkList

and LinkParam attributes, to be used

by the recipe executor at run-time.

External references contained within multi-part recipes

are not required to specify the class of the subrecipe

when the class is the same as that of the parent recipe.

Where class is omitted in a recipe identifier in the

ExtRef attribute, the link operation is responsible for

adding the class of the parent recipe in the identifier

added to the LinkList

parameter, as the parent/child

relationship cannot be derived from the final contents of

LinkList

External references are assumed to refer to recipes

within the same namespace and are not required to give

explicit versions unless they specify a different

namespace. This ensures that the user will be able to

link together the “best choice” subrecipes. The exact

value of versions of such references is determined only

at the time the main recipe is linked.

The link operation is performed on a main recipe. That

is, it only modifies attributes of the main recipe. It

resolves all external references within that recipe and

within any of its subrecipes according to well-defined

rules for determining default versions at the time of the

link. At the same time, variable parameter definitions

are collected. The resulting explicit references are

placed in the LinkList

attribute, variable parameter

definitions are placed in LinkParam

, the ApprovalLevel

attribute is cleared, the Linked

attribute is set to TRUE,

and the main recipe is then said to be linked.

Subrecipes are not affected by this operation.

Subrecipes of a main recipe have no knowledge of

parents or of linkages. As a result, it is possible to

delete or change a subrecipe with an unintended

detrimental impact on a linked recipe set. Factory

policy may designate certain levels of approval to mean

“this recipe is used by (linked into) one or more

protected recipes.”

For multi-part recipes, linking starts at the main recipe

and works through all chains of referenced subrecipes

to determine the complete set of identifiers that will

comprise the recipe as a whole. The link operation is a

mechanical procedure that may be performed at any

time.

Successful linking implies that all referenced subrecipes

have been located and parsed for further references

until all references are exhausted. The link operation

shall fail when any recipe or subrecipe within the

namespace either is unverified or cannot be located.

If the same parameter name is used to define a

parameter in more than one recipe of a set of recipes

that are linked together, the name shall represent the

same parameter and have the same parameter

definition in all recipes in the set, to avoid ambiguity.

Parameters with the same parameter name and

differing definitions shall cause, at a minimum, a

warning to the user when the link operation completes.

For purposes of comparison of results, the order of

references in LinkList

and LinkParam at the completion

of the link operation shall conform to the results when

the following sequence is used:

1. Copy the contents of ExtRef

from the main recipe to

LinkList

, resolving class and version to each recipe

identifier as needed. For support of variable

parameters, also copy the contents of Parameters to

LinkParam. If ExtRef is empty, then LinkList is also

empty and the parsing process is complete.

2. If LinkList

is not empty, begin with the first

reference in LinkList

as the link target reference.

3. If the link target reference lies within the same

namespace, resolve the class and version if

necessary. (Note: the referenced recipe must be

already present within the namespace at the time the

link is performed, or else the link fails.) If the link

target reference specifies a different namespace, go

to Step (6) — the link operation of this chain

terminates (without error) without an attempt to

locate the actual recipe or its ExtRef

attribute. If the