Method and system for specifying sets of instructions for selection by an instruction generator

A method for specifying a set of instructions selectable for generation by an instruction generator is disclosed. A class name representative of a class of instructions is identified and concatenated with a unique identifier label, thereby defining a unique singleton meta-mnemonic representative of a set of instructions. The class of instructions and the set of instructions are subsets of the instruction set of the processor. The resulting singleton meta-mnemonic specifies the set of instructions available for selection and generation by the instruction generator.

BACKGROUND OF THE INVENTION

The present disclosure relates generally to a method and apparatus for specifying a set of instructions for selection by an instruction generator, and particularly to a method and apparatus for dynamically and conditionally specifying a set of instructions that are available for selection by an instruction stream testcase generator when choosing the next instruction to generate.

Testing of a superscalar microprocessor architecture requires the generation of a large number of instruction sequences to assure that the microprocessor behaves properly under a wide variety of circumstances. Verification techniques generally require automated testing systems that can turn out high volume testcases in an effort to sufficiently cover the realm of possible behaviors of the integrated circuit being tested. Testcases may be generated by a testcase generator in accordance with parameters specified in a file that are provided by a software design specialist or engineer, otherwise the generator generates random testcases.

Generation of instruction sequences can be pseudo-randomly selected or guided based on templates in input files that are specified by the engineer that detail the instructions to generate. Each instruction selection within a template can be an explicit instruction mnemonic, such as,n1: LR, where the instruction LR is explicitly defined;a control statement that guides the selection of a given list of instruction mnemonics and/or macros, such as,Oneof(AR;AEBR;), where the control statement “Oneof” selects one explicit mnemonic from a list, such as a list of two as shown; ora group identifier/macro that gets replaced with a control statement and/or list of mnemonics, such as,AnyHalfOp( ) is defined as One of(LH;STH;)Sequence(1.5 AnyHalfOp( )), where the control statement Sequence selects a random range of 1 to 5 instances of the macro.

Control statements and macros are used to generalize the template so that various instruction combinations can be tested with only one template. Macros may be declared external to the template and imported into more than one template.

New instructions that are added to the architecture of a processor require testing, which typically involves updating macros or instruction templates previously defined, thereby enabling them to be included in the new instruction set. New macros also need to be manually created to handle new groupings of instructions, whether based on architecture attributes or user selected groupings, which typically involves listing each instruction that is a part of the newly created grouping. Occasionally, instructions need to be avoided in the testcase generation, whether due to a segmented design or an instruction that is not yet fully implemented. Additionally, each explicit mnemonic reference, control statement, or macro that uses the new instruction typically needs to be temporarily updated to remove the new instruction and then updated again when the instruction is available for testing.

Macros with large lists of instructions are storage and computationally intensive as they are expanded to create structures for each control statement and each mnemonic listed. Typically these macros are reused multiple times in an instruction stream template. When selecting instructions based on a specific state of the machine, a macro needs to be created for each instruction in this grouping and must be utilized with the corresponding initialization file to insure the existence of the specific state.

The architecture table is parsed and kept as an internal table to the generator. Use of the table facilitates testcase generation by having these instruction attributes and instruction operand characteristics readily available in a table lookup. Some of these instruction features include classifications of the instruction, that is, which class the instruction belongs to. The class identifier is a generic description for the type of instruction (such as Binary floating point), or what architecture facility it is a part of (such as Long Displacement Facility), or what format the instruction is (such RR, RRF, for example), or which architecture the instruction is valid in (such as zArch). Other instruction attributes and instruction operand attributes can be contained in the architecture table and can include instruction action (such as CC_Setter), or operand type (such as Fetch or Store).

Mnemonic specification for template guided instruction stream generation typically includes the use of explicit assembler mnemonics, control statements with a list of mnemonics, and group identifiers/macro expansion of mnemonics. Control statements guide the generation and selection of a given list of mnemonics. These control statements typically include the following types:Sequence(n..m <substream>), which psuedo-randomly selects a number (i), such that (n<=i<=m) and creates (i) instances of <substream>;Oneof(<substreamlist>), which psuedo-randomly selects and creates one element of the <substreamlist>;Anyorder(<substreamlist>), which psuedo-randomly creates any permutation of the order of the items in <substreamlist>;where,<substream> represents either an explicit mnemonic, macro, or control statement, and<substreamlist> represents a list of one or more <substream> elements.

As noted above, superscalar processors utilize large instruction sets that need to be tested by the production and execution of a large number of instruction sequences. To accomplish this, instruction stream testcase generators need to turn out high volume testcases in order to sufficiently cover the realm of possible behaviors of the integrated circuit being tested. Accordingly, it would be advantageous to have a testcase generator that could effectively and efficiently generate the necessary instruction stream testcases.

SUMMARY OF THE INVENTION

In one embodiment, a method for specifying a set of instructions selectable for generation by an instruction generator is disclosed. A class name representative of a class of instructions is identified and concatenated with a unique identifier label, thereby defining a unique singleton meta-mnemonic representative of a set of instructions. The class of instructions and the set of instructions are subsets of the instruction set of the processor. The resulting singleton meta-mnemonic specifies the set of instructions for execution by the processor.

In another embodiment, a processor programmed for specifying a set of instructions selectable for generation by an instruction generator is disclosed. The processor is programmed to identify a first class name representative of a first class of instructions and to concatenate the first class name with a unique identifier label, thereby defining a unique singleton meta-mnemonic representative of a set of instructions. The processor can also identify a second class name representative of a second class of instructions and concatenate the first class name with the second class name and a unique identifier label, thereby defining a unique compound meta-mnemonic representative of a second set of instructions, each instruction in the second set of instructions having membership in each of the classes. The processor can also concatenate a singleton meta-mnemonic or a compound meta-mnemonic with an exclusionary label, thereby defining an exclusionary meta-mnemonic representative of a third set of instructions, each instruction in the third set of instructions having membership outside of the set of instructions defined by the singleton meta-mnemonic and compound meta-mnemonic. The classes and sets of instructions are all subsets of the instruction set of the processor. The processor is programmed to use singleton, compound, and exclusionary meta-mnemonics for specifying an instruction set for selection by the instruction generator.

In a further embodiment, a method for specifying a set of instructions for selection by an instruction generator is disclosed. The existing state of a processor is referenced and the architecture mode of the processor is determined. The architecture table of the processor is referenced and it is determined whether the architecture mode is a valid architecture mode for an instruction, as determined by reference to the architecture mode in the architecture table for the instruction. A valid architecture class name is assigned to the instruction in response to the architecture mode of the processor being a valid architecture mode specified for the instruction in the architecture table. The resulting valid architecture class name specifies a valid set of instructions that are a subset of the processor instruction set and are available for selection and generation by the instruction generator.

DETAILED DESCRIPTION OF THE INVENTION

An embodiment of the invention provides a method of dynamically and conditionally specifying a set of instructions selectable for generation by an instruction stream testcase generator (ISTG). The ISTG consists of compiled code that runs on a processor, which generates an instruction for each instance of an instruction to be generated by selecting an instruction from the specified set. Sets of instructions are subsets of the processor's instruction set.

An instruction set differs from a set of instructions in that the instruction set is the set of instructions available to and particular to the processor, while the set of instructions is a subset of the instruction set available for selection by the testcase generator at a particular point in the generation of the test instruction stream. The instruction set of the processor is defined by the architecture table of the ISTG.

A class of instructions is a grouping of instructions that have similar attributes, such as: general; control; floating point; hex floating point; binary floating point (BFP); input/output (I/O); architecture (zArch for example); and, format (RR for example). Classes may also be instruction attributes, such as: “CC setting”; “PSW referencing”; “store type”; and “privileged type”, for example. They may also be the name of the architecture facility the instruction belongs to, such as: “Long Displacement”; and “Unicode”, for example.

The predefined instruction classes available that are typically utilized include:Categories;General,Control,Hex Floating Point (HFP),Binary Floating Point (BFP), for example);Features;the Architecture feature that the instructions belong to, such as Long Displacement Facility or Unicode, for example,which architecture the instruction is valid in, such as z/Arch or s/390, for example;Instruction Characteristic(s)/Attribute(s)/Action(s);Format, such as RR, RRF, for example,PSW_Reference, CC_Setter, serializing, privileged, for example,Instruction Type (Store, Fetch, Branch, for example),Implementation Type (Millicoded, or Hardwired(default), for example),Misc (Immediate data in instruction, interruptible, stacks, unstacks, can cause a trace entry, for example).

The format of the instruction set is typically architecture dependent. For example, in the z-architecture (zArch), an instruction is either one, two, or three halfwords in length and is located in storage on a halfword boundary. Each instruction is in one of 17 basic formats: E, RR, RRE, RRF, R, RXE, RXF, RS, RSE, RSI, RI, RIE, RIL, SI, S, SSE, and SS, with three variations of RRF, two variations of RS and RSE, and four variations of SS.

For example, an RR (register-register) instruction format is:

An RRE instruction format is:

An RX instruction format is:

FIG. 1is an exemplary embodiment of a method100whereby an ISTG specifies a set of instructions for execution by a processor. The method takes into account that the processor running the ISTG has associated with it an instruction set that includes certain classes of instructions with associated class names. In method100, the ISTG begins by identifying110a first class name representative of a first class of instructions. This first class name is then concatenated120with a unique identifier label (such as “_Op” for example) to provide a singleton meta-mnemonic of the form “<ClassName1>_Op”, which may then be specified130as the set of instructions from which the ISTG selects an instruction for execution by the processor. As used herein, a meta-mnemonic is an alphanumeric that can take the place of an exact assembler mnemonic (also referred to as mnemonic), but represents a subset of instructions that is resolved to a single mnemonic at runtime. The singleton meta-mnemonic identifies that set of instructions where each instruction belongs to the designated class <ClassName1>. A singleton meta-mnemonic is also referred to as a primitive meta-mnemonic. At140, the ISTG identifies a second class name representative of a second class of instructions, which is then concatenated150with the singleton meta-mnemonic to provide a compound meta-mnemonic of the form “<ClassName1>_<ClassName2>_Op”, which may then be specified160as the set of instructions from which the ISTG selects an instruction. At185, the ISTG identifies additional class names representative of additional classes of instructions, which can then be concatenated190with the compound meta-mnemonic. In this manner, further compound meta-mnemonics can be formed by concatenating a unique class name to a compound meta-mnemonic. The compound meta-mnemonic identifies that set of instructions where each instruction belongs to each of the designated classes <ClassName1> and <ClassName2>. At170, the ISTG creates an exclusionary set of instructions by concatenating an exclusionary label (such as “Non_” for example) with either a singleton meta-mnemonic or a compound meta-mnemonic to create an exclusionary meta-mnemonic of the form “Non_<ClassName1>_Op” or “Non_<ClassName1>_<ClassName2>_Op”, which may then be specified180as the set of instructions from which the ISTG selects an instruction. The exclusionary meta-mnemonic identifies that set of instructions where each instruction has membership outside of the set of instructions defined by the associated singleton mnemonic or compound mnemonic.

The following are examples of singleton meta-mnemonics, which are one class references: BFP_Op, which results in a set of instructions including binary floating point instructions; RR_Op, which results in a set of instructions including register-register formatted instructions; and, LWC_Op, which results in a set of instructions including membership in the LongWindedClass user defined class of instructions. The following are examples of compound meta-mnemonics, which are intersection or multi-class references: BFP_RR_Op and MyGroup_RRF_Op, which result in sets of instructions where each element is a member of each component class. The following are examples of exclusionary meta-mnemonics, which are prefixed singleton or compound meta-mnemonics that include all members not in the set described: Non_RR_Op, which results in a set of instructions that excludes those instructions having an RR format; Non_BFP_RR_Op, which results in a set of instructions that excludes those instructions that are binary floating point and RR format.

Thus, to specify a selection from the set of all instructions with an RR format, the meta-mnemonic RR_Op would be used. Similarly, to specify a selection from the set of all binary floating point instructions, the meta-mnemonic BFP_Op would be used. Contrasting the meta-mnemonics with a macro replacement scheme, to specify these sets of instructions with a macro replacement would entail defining the macro (e.g. Any_BFP_Op( )) and listing each instruction that is a member of that group. To create a group with only the binary floating point instructions that have RR formats, one would have to create a new macro (e.g. Any_BFP_RR_Op( )) and list only those instructions that are members of each group. In accordance with an embodiment of the invention, as disclosed herein, a set of instructions having only binary floating point instructions and RR formats would be represented by the compound meta-mnemonic BFP_RR_Op.

Specifying the set of all instructions that are not in the group having binary floating point instructions and RR format is formed by adding the exclusion prefix (Non_) to the compound meta-mnemonic, for example, Non_BFP_RR_Op. To use a macro or control statement with mnemonic lists to generate this grouping would entail listing the hundreds of instructions in this group.

Meta-mnemonics are very flexible and facilitate the writing of instruction templates. They also greatly reduce the amount of data and computations required when using the macro-replacement form. For example, without meta-mnemonics as herein disclosed, the creation of the group of instructions that are Hex Floating Point and RR Format would entail writing a macro that has 73 instructions, as represented by:

Using the compound meta-mnemonic HFP_RR_Op, the same set of instructions would be selected with one command. When using the exemplary macro above with a “Sequence” control statement, such as:Sequence(5...5 AnyHexFloatRROp( ));
each expansion of the macro would entail listing the control statement “Oneof”, followed by a list of 73 instructions to select from. In this example there would be 5×(1(control statement)+73(instructions)) of information required. Using the meta-mnemonic with the same control statement would be:Sequence(5..5 HFP_RR_Op);
which would result in only 5×1(instructions) of information required, and just one statement in a template.

An embodiment of the invention adds predefined dynamically-resolved classes and several predefined special case classes. These are not specified as part the architecture table associated with the processor. A dynamically-resolved class is based on the existing state of the processor, thus an instruction's membership to a dynamically-resolved class is conditional on the value of the mode or state in the processor. For example, in certain architectures some instructions are only valid in a specific architecture mode, such as z/Architecture or s/390. Some instructions are valid in both architectures. The architecture table for the processor specifies which instructions are valid for which architecture (the default is typically both if none is specified). In accordance with an embodiment of the invention, a predefined dynamically-resolved class of “ValidArch” is provided, which applies to an instruction only when the architecture mode of the processor is one of the valid architecture modes specified for the instruction in the architecture table for the processor. Also provided in an embodiment of the invention is a predefined special case class “Any”, which every instruction is a member of. Other predefined special case classes provided in accordance with an embodiment of the invention are “Abort” and “Disable”, which can only be used in the user-defined classes and are described in more detail below.

In an embodiment of the invention, users can define arbitrary classifications (user-defined classes) for instructions. These classes are similar to groupings in the macro-replacement scheme, discussed above, or where control statements are used with lists of mnemonics, but the meta-mnemonic method, as herein disclosed, has several advantages. A meta-mnemonic can be used to augment the membership of classes that an instruction belongs to, as defined by the ISTG's architecture table, by placing the user-defined classes in a user input file. A class name is first defined, and optionally abbreviated, then associated with one or more instructions. Alternatively, multiple classes may be associated with a single instruction. For example:to define a new user class with abbreviation, the format is,DEFINECLASS(LongWindedClass) ABBREV(LWC);to assign a new user class to an instruction, the format is,OP(57) MNEM(X) CLASS(LongWindedClass);to assign a new user class to instructions using a class abbreviation, the format is,MNEM(L,C) CLASS(LWC); andto temporarily disable the selection of instruction ST, the format is,MNEM(ST) CLASS(Disable).

An embodiment of the invention creates a predefined class name called “Disable”, which is only available in the user-defined class input file, and when associated with an instruction, removes this instruction from every class (see CLASS(Disable) discussed above). The use of “Disable” provides a quick and easy method of temporarily removing an instruction from a class, thereby preventing the instruction from being selected. In contrast, the macro-replacement or control statement methods require that all files with this instruction be updated. Another predefined class available with an embodiment of the invention is “Abort”, which when associated with an instruction, aborts the testcase generated when the associated instruction is encountered. The difference between “Disable” and “Abort” is that “Disable” prevents generation of an associated instruction, while “Abort” prevents the creation of a testcase with the associated instruction. The “Abort” sequence may occur due to self-modifying code not related to an instruction template, or due to a testcase generation guided by an instruction template.

An embodiment of the invention enables a user-defined class definition to have a conditional expression, based on the state, or mode, of the processor, to determine when the class is valid. A conditional expression permits the definition of user-defined dynamically-resolved classes to be based on the current state (or existing state) of the processor. The user-defined classes can reference register bits/values and modes of the processor. For example:to define a dynamically-resolved class to only be valid when in zArchitecture and mode trace are active, the format is,DEFINECLASS(MillicodedTrace) WHEN(zArch && CR9.ModeTrace); andto assign a new user class to an instruction, the format is,MNEM(BASSM) CLASS(MillicodedTrace).The syntax for the user input file describing user-defined and user-defined dynamically resolved classes is:

The user input file for class definitions is parsed, and each new defined condition/class/abbreviation (element) is checked for uniqueness with other elements of the same type. In an embodiment, structures are created for holding the class name and optional abbreviation (default is null if not supplied) and optional associated expression (default is null if not specified). Each new class receives an assigned bit to represent it in the user class data area, with each bit being sequentially assigned from left to right. Other bit assignments may be possible without detracting from the teachings of the disclosed invention. To accommodate the new classes, the internal representation of the processor's architecture table is expanded to include a new field for each instruction's user-defined classes. The new field contains a bit map of user classes associated with the instruction, and is referenced when the ISTG evaluates the meta-mnemonics. During runtime, if there is an expression associated with the user-defined class, the expression is parsed and kept as a binary expression tree. The ISTG evaluates the expression when referencing membership in the subject class. The predefined classes can be represented by having bits of a structure represent each class, or by encoding several bits to represent a class (e.g. format). When the architecture table is parsed, it creates the structure for the classes that the instruction belongs to, and sets those bits to On. For example:OP(2A) MNEM(ADR) FMT(RR) CLASS(HFP,CC_Set)
would indicate that the ADR instruction has classes HFP, CC_Set, and RR format enabled. The internal representation of the architecture table contains a field for the predefined static, dynamically-resolved, and special case classes.

When generating an instruction requiring determination of membership in a class, the user-defined class fields quickly and simultaneously determine membership in any class or multiple classes. Each class is represented by a unique bit value or by a unique encoding of bits. A compound meta-mnemonic would be represented by the logical OR-ing of the unique class bits of its component classes. To determine membership of an instruction in a class, one would logically AND the unique bits of the class wanted, represented by the meta-mnemonic, with the instruction's unique class information, and if it equaled the wanted class then the instruction would be a member of that class.

The predefined dynamically-resolved classes utilize the current state of the processor to determine if an instruction is a member. For the user-defined dynamically-resolved classes, the binary expression tree for the condition is evaluated to determine class inclusion. This evaluation consists of evaluating each part of the expression tree. Machine state variables (register, register components, modes, etc., including dynamic architecture values depending on mode (e.g. Length of page table entry)) and/or literals, get evaluated to values and then the conditions evaluated.

As discussed above, the created meta-mnemonic is formed by concatenating the class name with (_Op) for ease of identification and uniqueness of name with the current mnemonics. Meta-mnemonics are resolved at runtime and take up the same amount of instruction node space as one explicit mnemonic. While typical macros expand to have one structure for each instruction in the expansion, meta-mnemonics as herein disclosed would only take one structure, like an explicit instruction, which are then replaced with any instance of the specified set.

Utilizing the predefined dynamically-resolved class “ValidArch”, discussed above, one can, in the current architecture mode irregardless of which mode it is, readily specify the group of instructions eligible for selection to be valid by using the meta-mnemonic ValidArch_Op, or to be invalid by using the meta-mnemonic Non_ValidArch_Op. Utilizing the user-defined dynamically-resolved class “MillicodedTrace”, one can readily specify the avoidance of any instruction that is dynamically determined to currently be executed in millicode by using the meta-mnemonic Non_MillicodedTrace_Op. This flexibility removes the need to maintain separate macros or explicit mnemonic templates and their accompanying initialization files that insure those relationships. Utilizing the predefined special class “Any_Op”, one can readily specify the selection of any instruction defined.

In an embodiment, there exists three control flow type instructions. The first is Sequential, where flow continues to the next adjacent instruction. The next two, Jump and Branch, are both non-sequential. In a Jump instruction, flow goes to the specified target instruction. In a Branch instruction, flow is based on a conditional check and either jumps to a target instruction or continues with the next sequential instruction. Jump and Branch type instructions must be specified with a target node, whereas sequential instructions must have no target node. An embodiment of the invention factors this template information, regarding target node and no target node, into the meta-mnemonic expression resolution. Accordingly, if the instruction location has no target node, thereby denoting a sequential instruction, then only sequential type instructions are permitted to be selected and any Jump/Branch types of instructions are skipped. Conversely, if the instruction location has a target node specified, thereby denoting a non-sequential instruction, then no sequential instructions are eligible for selection and they are skipped. This implicit handling of control flow and restricting the instructions selected facilitates selecting the correct kind of instruction for every instruction location, and assists the template writer by not requiring the explicit handling of control flow at every instruction.

FIG. 2depicts an illustrative representation of implicit control flow200controlled by a processor205, where the processor instruction set210includes a set of instructions to be selected220. The set of instructions to be selected is restricted to subset-A230that includes a first type of instruction (such as sequential type instructions (A)) if instruction-x240includes a first condition (such as no target node (x)). The set of instructions to be selected is restricted to subset-B250that includes a second type of instruction (such as non-sequential type instructions (B)) if instruction-y260includes a second condition (such as a target node (y)).

A further embodiment of the invention provides for utilization of complex set expressions with set operators. These set expressions can reside in the same location a mnemonic or meta-mnemonic can reside. The set operators include the following:Union (|), which is a binary operator that includes all elements of both sets;Intersection(&), which is a binary operator that includes only those elements in both sets;Union less Intersection (^) (XOR), which includes elements in only one set but not both; andExclusion(!), which is a unary operator that includes everything NOT in the specified set.The syntax for the set expressions is:

In a further embodiment, one can conditionally select between two sets of descriptions of instructions based on the current state/mode of the processor. The syntax takes the form of the class syntax conditional expression using the ternary operator “?”, noted above. In the expression <condexpr>?<setexpr1>:<setexpr2>, <condexpr> is evaluated as a conditional expression. If the result of the conditional expression is true, then <setexpr1> is used, else <setexpr2> is used. Thus, in the following example,PSW.ProblemState?{!Priv_Op}:{Priv_Op},
the result used is based on the current state of the PSW problem state. If the processor is in the problem state (true), then the set of instructions that are not privileged are used. If the processor is not in the problem state (false), then the set of instruction that are privileged are used. This capability of dynamically selecting a set of instructions from multiple sets of instructions is another advantage of meta-mnemonics and the methods herein disclosed.

FIG. 3depicts a general flowchart300of the dynamic selection process, which begins with the availability of sets of instructions such as singleton, compound and exclusionary meta-mnemonics310. From block310, the flowchart can either pass to the user-defined explicit selection block320, or to the user-defined conditional selection block330. At block320, selection between two sets of instructions is accomplished by explicitly selecting a set of instructions based on a user-defined control statement, thereby resulting in the set of instructions available for selection by the instruction stream generator, block350. At block330, selection between two sets of instructions is accomplished by conditionally selecting a set of instructions based on the current state of the processor, which is resolved at runtime at block340. The end result is also a set of instructions for execution by the processor, block350.

During runtime, the instruction template guiding the instruction sequence generation is parsed and maintained as a linked-list of nodes, where each node contains information about the instruction to be generated. If the instruction is an explicit mnemonic, then that mnemonic is placed in the node. If the instruction is a control statement with a list of mnemonics, then a separate linked-list of the control statement and associated mnemonics is maintained with a node for each. Prior to parsing, a preprocessor is invoked which replaces all instances of a macro with its definition in-line. When the instruction is defined by a singleton meta-mnemonic, compound meta-mnemonic or expression of meta-mnemonics, an additional component is added to each instruction node that contains the pointer of the expression for the instruction. The singleton meta-mnemonics and compound meta-mnemonics are converted410to an simple expression which contain only the value of the meta-mnemonic, best seen by referring to the process400depicted inFIG. 4. Expressions are parsed and maintained as binary expression trees420. These expression trees contain values for operators, operands and the meta-mnemonics and/or mnemonics specified. These expression trees also contain the conditional ternary operators and the resulting set definitions. When expressions are encountered in evaluation, the current state of the machine is referenced430by the machine state symbolic operands, the expression is calculated, and the ternary operator is evaluated to determine440which set of instructions to utilize.

Meta-mnemonics as herein disclosed have more flexibility than the macro-replacement or group identifier methods, utilize less storage and processing time, and are easier to maintain. Additionally, embodiments of the invention provide for: increased speed of generating a testcase by utilizing less internal storage/structures as expanded macros; reduced maintenance/duplication; reduced need for updating multiple macros; reduced need for creating new macros; ease of temporarily disabling instructions; increased flexibility of selecting instructions to select from; set expression support; conditionally selecting sets and dynamically-resolved classes (predefined or user-defined) that reduce the number of templates and overhead for specific initialization files and environments; and, implicit filtering for instruction flow type (sequential vs. non-sequential), which reduces the need for an explicit definition for each instruction.